package com.westos.userauth.service.impl;

/**
 * @Description
 * @Date 2020/11/1 14:41
 * @Created by 张琳梓、李瑞、张佳妮
 */

import com.westos.userauth.domain.*;
import com.westos.userauth.dto.PartyPrintDto;
import com.westos.userauth.dto.PartySearchDto;
import com.westos.userauth.service.PartyService;
import com.westos.userauth.dao.*;
import com.westos.userauth.util.Constants;
import com.westos.userauth.util.JudgeString;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class PartyServiceImpl implements PartyService {

    /*** 可能会使用到的dao层对象
     */
    @Autowired
    private PartyAttributeDao partyAttributeDao;
    @Autowired
    private PartyDao partyDao;
    @Autowired
    private PartyGroupDao partyGroupDao;
    @Autowired
    private PartyRoleDao partyRoleDao;
    @Autowired
    private PersonDao personDao;
    @Autowired
    private UserLoginDao userLoginDao;

    private Logger logger = LoggerFactory.getLogger(PartyServiceImpl.class);

    /** 需要实现的方法
     * */

    @Override
    public Boolean deleteParty(String partyId) {
        try {
            if (partyId == null)
                return false;

            if ("".equals(partyId)) {
                //log.warn();
                logger.warn("partyId为空！");
                return false;
            }

            personDao.deletePersonByPartyId(partyId);
            partyAttributeDao.deletePartyAttributeByPartyId(partyId);
            partyGroupDao.deletePartyGroupByPartyId(partyId);
            partyRoleDao.deletePartyRoleByPartyId(partyId);
            int i = partyDao.deletePartyByPartyId(partyId);
            if (i > 0)
                return true;
            else
                return false;
        } catch (Exception ex) {
            logger.error("执行dao层代码出错！");
            ex.printStackTrace();
            return false;
        }
    }

    /*** 设置party状态码————张琳梓
     * */
    @Override
    public Boolean setPartyStatus(Party party, String status) {
        if (status == null)
            return false;

        if ("".equals(status))
            return false;

        if (party == null)
            return false;

        if (status.equals(Constants.N)) {

            UserLogin userLogin = userLoginDao.queryByPartyId(party.getPartyId());

            if (userLoginDao.queryByPartyId(party.getPartyId()) != null) {
                userLogin.setEnabled(Constants.N);
                userLogin.setDisabledDateTime(new Date());
                userLogin.setDisabledBy(party.getCreatedByUserLogin());
                logger.info("设置不能登录");
            } else {
                logger.info("该party所对应的用户登录信息不存在！");
            }
        }

        try {

            int i = partyDao.updatePartyByStatus(party, status);
            if (i > 0)
                return true;
        } catch (Exception e) {
            e.printStackTrace();
        }


        return false;
    }

    /*** 创建person对象————张琳梓
     * */
    @Override
    public Person createPerson(Person person) {
        if (person == null)
            return null;

        //重要属性的判断
        String partyId = person.getPartyId();

        if ("".equals(partyId) || partyId == null) {
            logger.error("参数person的partyId属性值不存在，请检查！");
            return null;
        }

        boolean b = JudgeString.judgeStr(partyId);
        if (!b) {
            logger.error("partyId中包含特殊字符，请检查");
        }

        Party party = new Party();
        party.setPartyId(partyId);
        try {
            if (partyDao.queryPartyByPartyId(party.getPartyId()) != null) {
                Date date = new Date();
                person.setCreatedStamp(date);

                if (personDao.insertPerson(person))
                    return person;
            } else {
                /*
                 * 如果找不到关联的对应的party表
                 * */
                IdServiceSnowImpl idServiceSnow = new IdServiceSnowImpl();
                String nameId = idServiceSnow.getIdByName(person.getFirstName());
                Party party1 = new Party();
                party1.setPartyId(nameId.substring(0,10));
                party1.setCreatedDate(new Date());
                partyDao.insertParty(party1);
                person.setPartyId(party1.getPartyId());
                personDao.insertPerson(person);
            }
        } catch (Exception e) {
            logger.error("调用dao层出错！" + e.getMessage());
        }
        return null;
    }

    /*** 创建PartyAttribute对象————张琳梓
     * */
    @Override
    public Boolean createPartyAttribute(PartyAttribute partyAttribute) {
        boolean flag = false;
        try {
            Party party = new Party();
            party.setPartyId(partyAttribute.getPartyId());

            if (partyAttribute == null)
                return false;

            if (partyAttribute.getPartyId() == null) {
                logger.info("partyAttribute中的partyId为null");
                return false;
            }

            //重要属性的判断
            String attrName = partyAttribute.getAttrName();


            if ("".equals(attrName) || attrName == null) {
                logger.info("形参partyAttribute的attrName属性值不存在，请检查！");
                return false;
            }

            if (partyAttributeDao.queryAttributeByAttrName(attrName).size()>0) {
                logger.info("属性已经存在，不可重复添加");
                return false;
            }

            boolean b = JudgeString.judgeStr(attrName);
            if (!b) {
                logger.info("attrName中包含特殊字符，请检查");
            }

            if (partyDao.queryPartyByPartyId(party.getPartyId()) != null) {
                Date date = new Date();
                partyAttribute.setCreatedStamp(date);
                partyAttribute.setLastUpdatedStamp(date);
                if (partyAttributeDao.insertPartyAttribute(partyAttribute) > 0)
                    flag = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }



    /*** 更新PartyAttribute————张佳妮
     */
    @Override
    public Boolean updatePartyAttribute(PartyAttribute partyAttribute) {
        /*** 校验partyAttribute是否为空
         */
        if (partyAttribute == null) {
            logger.error("形参partyAttribute对象为空！");
            return false;
        }

        /*** partyAttribute对象中重要属性partyId的校验
         */

        //判断partyAttribute的PartyId属性值是否为空或者不存在
        if (StringUtils.isBlank(partyAttribute.getPartyId())) {
            logger.error("形参partyAttribute对象的PartyId属性值为空或者不存在，这可能是一个垃圾数据！");
            return false;
            //作为垃圾数据存在
        }

        //判断partyId长度是否符合要求以及是否含有特殊字符
        if (partyAttribute.getPartyId().length() > 20 || !JudgeString.judgeStr(partyAttribute.getPartyId())) {
            logger.error("请检查形参partyAttribute对象的PartyId属性值的长度或者是否含有特殊字符！");
            return false;
        }

        //调用dao层判断partyId是否有对应的party对象与之匹配
        Party party = partyDao.queryPartyByPartyId(partyAttribute.getPartyId());
        if (party == null) {
            //作为垃圾数据存在
            logger.error("没有Party对象与形参partyAttribute对象的PartyId属性值匹配起来，这可能是一个垃圾数据！");
            //没必要继续下面的逻辑
            return false;
        }

        /*** partyAttribute对象中属性attrName、attrValue的非空校验、含有特殊字符校验
         */

        if (StringUtils.isBlank(partyAttribute.getAttrName())) {
            logger.error("partyAttribute对象的属性值attrName不存在！");
            return false;
        }

        if (StringUtils.isBlank(partyAttribute.getAttrValue())) {
            logger.error("partyAttribute对象的属性值attrValue不存在！");
            return false;
        }

        if (!JudgeString.judgeStr(partyAttribute.getAttrName())) {
            logger.error("partyAttribute对象的属性值attrName包含有特殊字符，请检查！");
            return false;
        }

        if (!JudgeString.judgeStr(partyAttribute.getAttrValue())) {
            logger.error("partyAttribute对象的属性值attrValue包含有特殊字符，请检查！");
            return false;
        }

        try {
            //在更新数据之前，给这个对象填充部分属性
            partyAttribute.setLastUpdatedStamp(new Date());

            //调用dao层
            int i = partyAttributeDao.updatePartyAttribute(partyAttribute);
            if (i > 0) {
                logger.trace("更新数据成功！");
                return true;
            }
        } catch (Exception e) {
            logger.error("更新数据失败！" + e.getMessage());
            return false;
        }
        return false;
    }

    /*** 移除PartyAttribute————张佳妮
     */
    @Override
    public Boolean removePartyAttribute(PartyAttribute partyAttribute) {

        /***
         * 判校验partyAttribute是否为空
         */
        if (partyAttribute == null) {
            logger.error("形参partyAttribute对象为空！");
            return false;
        }

        /***
         * partyAttribute对象中重要属性partyId的校验
         */
        //判断partyAttribute的PartyId属性值是否为空或者不存在
        if (StringUtils.isBlank(partyAttribute.getPartyId())) {
            logger.error("形参partyAttribute对象的PartyId属性值为空或者不存在，这可能是一个垃圾数据！");
            //作为垃圾数据存在
            return false;
        }

        /***
         * 调用dao层接口
         */
        try {
            //调用dao层
            int i = partyAttributeDao.deletePartyAttribute(partyAttribute.getPartyId());
            if (i > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("删除数据失败！" + e.getMessage());
        }
        return false;

    }

    /*** 条件查询party————张佳妮
     */
    @Override
    public List<PartyPrintDto> lookupParty(PartySearchDto partySearchDto) {
        //定义一个结果集
        List<PartyPrintDto> dtoList = null;

        if (partySearchDto == null) {
            logger.error("partySearchDto对象不存在");
            return dtoList;
        }

        try {
            /*** 校验各个属性值是否存在
             */

            //判断partyAttribute的PartyId属性值是否为空或者不存在
            if (StringUtils.isBlank(partySearchDto.getPartyId())) {
                logger.info("形参partySearchDto对象的PartyId属性值为空或者不存在！");
            }
            //判断partyId长度是否符合要求以及是否含有特殊字符
            if (partySearchDto.getPartyId().length() > 20 || !JudgeString.judgeStr(partySearchDto.getPartyId())) {
                logger.error("请检查形参partySearchDto对象的PartyId属性值的长度或者是否含有特殊字符！");
                return dtoList;
            }

            if (!StringUtils.isBlank(partySearchDto.getAttrName()) && !StringUtils.isBlank(partySearchDto.getAttrValue())) {
                //如果这两个属性都不为空，判断数据库中的数据是否能匹配的上

                //定义布尔类型的值，用于标记是否存在这样的value与给定的value相同
                Boolean flag = false;

                //查询数据库，并遍历查询出来的结果，看是否存在value值与给定的value值对应
                List<PartyAttribute> attributeList = partyAttributeDao.queryAttributeByAttrName(partySearchDto.getAttrName());
                for (int i = 0; i < attributeList.size(); i++) {
                    if (attributeList.get(i).getAttrValue().equals(partySearchDto.getAttrValue())) {
                        flag = true;
                        break;
                    }
                }

                if (flag) {
                    logger.error("这是一个错误的数据，它的属性名与属性值不匹配！");
                    return dtoList;
                }
            }

            //判断partySearchDto的RoleTypeId属性值是否为空或者不存在
            if (StringUtils.isBlank(partySearchDto.getRoleTypeId())) {
                logger.info("形参partySearchDto对象的RoleTypeId属性值为空或者不存在！");
            }
            //判断RoleTypeId长度是否符合要求以及是否含有特殊字符
            if (partySearchDto.getRoleTypeId().length() > 20 || !JudgeString.judgeStr(partySearchDto.getRoleTypeId())) {
                logger.error("请检查形参partySearchDto对象的RoleTypeId属性值的长度或者是否含有特殊字符！");
                return dtoList;
            }

            //判断partySearchDto的partyTypeId属性值是否为空或者不存在
            if (StringUtils.isBlank(partySearchDto.getPartyTypeId())) {
                logger.info("形参partySearchDto对象的partyTypeId属性值为空或者不存在！");
            }
            //判断partyTypeId长度是否符合要求以及是否含有特殊字符
            if (partySearchDto.getPartyTypeId().length() > 20 || !JudgeString.judgeStr(partySearchDto.getPartyTypeId())) {
                logger.error("请检查形参partySearchDto对象的partyTypeId属性值的长度或者是否含有特殊字符！");
                return dtoList;
            }

            //判断partySearchDto的createdByUserLogin属性值是否为空或者不存在
            if (StringUtils.isBlank(partySearchDto.getCreatedByUserLogin())) {
                logger.info("形参partySearchDto对象的createdByUserLogin属性值为空或者不存在！");
            }
            //判断createdByUserLogin长度是否符合要求以及是否含有特殊字符
            if (partySearchDto.getCreatedByUserLogin().length() > 250 || !JudgeString.judgeStr(partySearchDto.getCreatedByUserLogin())) {
                logger.error("请检查形参partySearchDto对象的createdByUserLogin属性值的长度或者是否含有特殊字符！");
                return dtoList;
            }

            //判断partySearchDto的lastModifiedByUserLogin属性值是否为空或者不存在
            if (StringUtils.isBlank(partySearchDto.getLastModifiedByUserLogin())) {
                logger.info("形参partySearchDto对象的lastModifiedByUserLogin属性值为空或者不存在！");
            }
            //判断createdByUserLogin长度是否符合要求以及是否含有特殊字符
            if (partySearchDto.getLastModifiedByUserLogin().length() > 250 || !JudgeString.judgeStr(partySearchDto.getLastModifiedByUserLogin())) {
                logger.error("请检查形参partySearchDto对象的lastModifiedByUserLogin属性值的长度或者是否含有特殊字符！");
                return dtoList;
            }

            if (partySearchDto.getCreatedDate() == null) {
                logger.info("形参partySearchDto对象的createdDate属性值为NULL！");
            }

            if (partySearchDto.getLastModifiedDate() == null) {
                logger.info("形参partySearchDto对象的lastModifiedDate属性值为NULL！");
            }

        } catch (Exception e) {
            logger.info("输入参数的部分属性值为空或调用dao层异常！");
            //return null;
        }

        //调用dao层
        try {
            dtoList = new ArrayList();

            //查询多个dao层
            List<Party> partyList = partyDao.lookupParty(partySearchDto);
            PartyAttribute partyAttribute = partyAttributeDao.queryAttribute(partySearchDto.getPartyId());
            PartyGroup partyGroup = partyGroupDao.selectPartyGroupById(partySearchDto.getPartyId());

            //做一个数据的封装并返回给调用层
            for (int i = 0; i < partyList.size(); i++) {
                Party party = partyList.get(i);
                PartyPrintDto partyPrintDto = new PartyPrintDto();

                //将结果封装到返回的对象中
                partyPrintDto.setDescription(party.getDescription());
                partyPrintDto.setCreatedDate(party.getCreatedDate());
                partyPrintDto.setCreatedByUserLogin(party.getCreatedByUserLogin());
                partyPrintDto.setAttrName(partyAttribute.getAttrName());
                partyPrintDto.setAttrValue(partyAttribute.getAttrValue());
                partyPrintDto.setGroupName(partyGroup.getGroupName());

                //给输出的对象的系统时间属性设值
                partyPrintDto.setCreatedStamp(new Date());
                //将每一个对象存入结果集
                dtoList.add(partyPrintDto);
            }

            logger.trace("查询数据成功！");
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("查询数据失败！" + e.getMessage());
            return null;
        }
        return dtoList;
    }

    /*** 通过id查询party————张佳妮
     */
    @Override
    public PartyPrintDto findPartiesById(String id) {
        //创建PartyPrintDto作为结果
        PartyPrintDto partyPrintDto = new PartyPrintDto();

        //判断id属性值是否为空或者不存在
        if (StringUtils.isBlank(id)) {
            logger.error("形参id值为空或者不存在！");
            return null;
        }

        //判断partyId长度是否符合要求以及是否含有特殊字符
        if (id.length() > 20 || !JudgeString.judgeStr(id)) {
            logger.error("请检查形参id的长度或者是否含有特殊字符！");
            return null;
        }

        try {
            Party party = partyDao.findPartiesById(id);
            PartyAttribute partyAttribute = partyAttributeDao.queryAttribute(id);
            PartyGroup partyGroup = partyGroupDao.selectPartyGroupById(id);

            if (party != null) {
                logger.trace("查询数据成功！");

                //将结果封装到返回的对象中
                partyPrintDto.setDescription(party.getDescription());
                partyPrintDto.setCreatedDate(party.getCreatedDate());
                partyPrintDto.setCreatedByUserLogin(party.getCreatedByUserLogin());

                partyPrintDto.setAttrName(partyAttribute.getAttrName());
                partyPrintDto.setAttrValue(partyAttribute.getAttrValue());

                partyPrintDto.setGroupName(partyGroup.getGroupName());

                //给输出的对象的系统时间属性设值
                partyPrintDto.setCreatedStamp(new Date());

                return partyPrintDto;
            }

            logger.error("没有与这个id对应的party对象！");
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("查询数据库失败！" + e.getMessage());
            return null;
        }
    }

    /*** 更新person对象————李瑞
     */
    @Override
    public Boolean updatePerson(Person person) {
        //判断person是否为null
        if (person == null) {
            logger.error("person为null,无法更新用户");
            return false;
        }

        //获取用户partyId 判断partyId是否可用
        if (StringUtils.isBlank(person.getPartyId())) {
            logger.error("partyId不可使用,无法更新用户信息");
            return false;
        }

        //不能匹配特殊字符 列如：@、#、￥、%、^
        if (!JudgeString.judgeStr(person.getPartyId())) {
            logger.error("出现特殊字符");
            return false;
        }

        //判断用户的姓名是否为空
        if (StringUtils.isBlank(person.getFirstName())) {
            logger.error("名字不存在");
            return false;
        }

        //用户名不能匹配特殊字符 列如：@、#、￥、%、^
        if (!JudgeString.judgeStr(person.getFirstName())) {
            logger.error("出现特殊字符");
            return false;
        }

        //根据用户的partyId查询用户
        Person oldPerson = personDao.queryById(person.getPartyId());
        if (oldPerson == null) {
            logger.error("用户不存在，无法进行更新");
            return false;
        }


        //调用dao层接口 判断是否更新成功


        try {
            int row = personDao.updatePerson(person);
            if (row > 0) {
                logger.trace("更新成功！");
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        logger.error("更新失败！");
        return false;
    }

    /*** 创建partyGroup对象————李瑞
     */
    @Override
    public PartyGroup createPartyGroup(PartyGroup partyGroup) {

        if (partyGroup == null) {
            logger.error("partyGroup无数据,无法添加");
            return null;
        }

        //添加的用户组 必须的有一个编号
        if (StringUtils.isBlank(partyGroup.getPartyId())) {
            logger.error("partyId为null");
            return null;
        }

        //用户名不能匹配特殊字符 列如：@、#、￥、%、^
        if (!JudgeString.judgeStr(partyGroup.getPartyId())) {
            logger.error("出现特殊字符");
            return null;
        }

        //用户组得有一个用户组名
        if (StringUtils.isBlank(partyGroup.getGroupName())) {
            logger.error("用户组名字为空");
            return null;
        }

        //用户名不能匹配特殊字符 列如：@、#、￥、%、^
        if (!JudgeString.judgeStr(partyGroup.getGroupName())) {
            logger.error("出现特殊字符");
            return null;
        }

        //给用户设置创建时间
        partyGroup.setCreatedStamp(new Date());
        //查询是否插入相同用户
        PartyGroup oldPartyGroup = partyGroupDao.selectPartyGroupById(partyGroup.getPartyId());
        if (oldPartyGroup!=null){
            logger.error("用户已存在,不能重复创建");
            return null;
        }

        //调用dao层
        try {
            int row = partyGroupDao.insertPartyGroup(partyGroup);
            if (row > 0) {
                logger.trace("创建成功");
                return partyGroup;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        logger.error("创建失败");
        return null;
    }

    /*** 修改用户组————李瑞
     */
    @Override
    public Boolean updatePartyGroup(PartyGroup partyGroup) {

        if (partyGroup == null) {
            logger.error("partyGroup为null，无法更新");
            return false;
        }
        if (StringUtils.isBlank(partyGroup.getPartyId())) {
            logger.error("partyId不可使用,无法更新用户信息");
            return false;
        }

        if (!JudgeString.judgeStr(partyGroup.getPartyId())) {
            logger.error("出现特殊字符");
            return false;
        }

        if (StringUtils.isBlank(partyGroup.getGroupName())) {
            logger.error("用户组名为空");
            return false;
        }

        Long numEmployees = partyGroup.getNumEmployees();
        if (numEmployees == null) {
            logger.error("该团队组无人员");
            return false;
        }

        String comments = partyGroup.getComments();
        if (comments.length() == 0) {
            logger.error("该团队没有评论信息");
            return false;
        }

        PartyGroup oldPartyGroup = partyGroupDao.selectPartyGroupById(partyGroup.getPartyId());
        if (oldPartyGroup == null) {
            logger.error("不存在该用户,更新无意义");
            return false;
        }

        //调用dao层 执行更新方法
        try {
            int row = partyGroupDao.updatePartyGroup(partyGroup);
            if (row > 0) {
                logger.trace("更新成功");
                return true;
            }
        } catch (Exception e) {
            logger.error("更新失败");
            e.printStackTrace();
        }
        return false;
    }

    /*** 更新用户组名字变化————李瑞
     * @Deprecated 方法失效——没有对应的数据表
     */
    @Override
    public int savePartyNameChange(PartyGroup partyGroup, String newName) {
        //partyGroup是否可用
        if (partyGroup == null) {
            logger.error("partyGroup没有数据无法添加用户");
            return 0;
        }
        //判断新名字是否可用
        if (StringUtils.isBlank(newName)) {
            logger.error("新用户名为空不可以使用");
            return 0;
        }
        //可用判断是否符合规则

        if (!JudgeString.judgeStr(newName)) {
            logger.error("新名字不符合规则");
            return 0;
        }

        //判断id是否为空
        if (StringUtils.isBlank(partyGroup.getPartyId())) {
            logger.error("partyId不可使用,无法更新用户信息");
            return 0;
        }
        //判断名字是否为空
        if (StringUtils.isBlank(partyGroup.getGroupName())) {
            logger.error("用户名未指定,无法查询用户信息");
            return 0;
        }
        //查询用户是否存在
        PartyGroup group = partyGroupDao.selectPartyGroupById(partyGroup.getPartyId());
        if (group == null) {
            logger.error("不存在要修改的用户");
            return 0;
        }
        //调用dao层进行更新数据
        try {
            int row = partyGroupDao.updatePartyGroupByName(partyGroup, newName);
            if (row > 0) {
                logger.trace("更新成功!");
            }
        } catch (Exception e) {
            logger.error("更新失败!");
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public List<Person> getPartyNameForDate(Date date) {
        return null;
    }

    //暂时不需要使用的方法

    /*** 根据日期或取名字————李瑞
     * @Deprecated 方法失效——没有对应的数据表
     */
    /*@Override
    public List<Person> getPartyNameForDate(Date date) {
        //date为null 提示用户
        if (date == null) {
            logger.error("日期为null,无法获取用户的名字");
            return null;
        }
        //调用dao层接口查询
        List<Person> people = personDao.queryPerson(date);
        for (int i = 0; i < people.size(); i++) {
            //获取查询出来的所有对象
            Person person = people.get(i);
            if (StringUtils.isBlank(person.getPartyId())) {
                logger.error("partyId不可使用,更新不了数据");
                return null;
            }
            //获取用户名字
            if (StringUtils.isBlank(person.getFirstName())) {
                logger.error("firstName,数据不可使用");
                return null;
            }
            if (!JudgeString.judgeStr(person.getFirstName())) {
                logger.error("新名字不符合规则");
                return null;
            }
            //检查创建时间
            Date createdStamp = person.getCreatedStamp();
            if (createdStamp == null) {
                logger.error("无法获取用户创建的时间");
                return null;
            }
            //获取用户动态时间
            Date lastUpdatedStamp = person.getLastUpdatedStamp();
            if (lastUpdatedStamp == null) {
                logger.error("用户没有存在的动态时间");
                return null;
            }
        }
        return null;
    }*/
    @Override
    public void createPersonAndUserLogin() {

    }


    /**
     * dao 层对象的 get 和 set访问器
     */
    public PartyAttributeDao getPartyAttributeDao() {
        return partyAttributeDao;
    }

    public void setPartyAttributeDao(PartyAttributeDao partyAttributeDao) {
        this.partyAttributeDao = partyAttributeDao;
    }

    public PartyDao getPartyDao() {
        return partyDao;
    }

    public void setPartyDao(PartyDao partyDao) {
        this.partyDao = partyDao;
    }

    public PartyGroupDao getPartyGroupDao() {
        return partyGroupDao;
    }

    public void setPartyGroupDao(PartyGroupDao partyGroupDao) {
        this.partyGroupDao = partyGroupDao;
    }

    public PartyRoleDao getPartyRoleDao() {
        return partyRoleDao;
    }

    public void setPartyRoleDao(PartyRoleDao partyRoleDao) {
        this.partyRoleDao = partyRoleDao;
    }

    public PersonDao getPersonDao() {
        return personDao;
    }

    public void setPersonDao(PersonDao personDao) {
        this.personDao = personDao;
    }

    public UserLoginDao getUserLoginDao() {
        return userLoginDao;
    }

    public void setUserLoginDao(UserLoginDao userLoginDao) {
        this.userLoginDao = userLoginDao;
    }
}
